package com.taichuan.selfcheck.mvp.presenter;


import android.annotation.SuppressLint;
import android.util.Log;
import com.taichuan.mvp.base.MvpBasePresenter;
import com.taichuan.selfcheck.entity.file.FileInfo;
import com.taichuan.selfcheck.mvp.viewinterface.FileListInterface;
import com.taichuan.tcutils.common.FileUtils;
import com.taichuan.tcutils.common.TimeUtils;
import com.taichuan.tcutils.taichuan.SystemUtils;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;

/**
 * Created by CamelLuo on 2018/6/21.
 */
public class FileListPresenter extends MvpBasePresenter<FileListInterface> {
    private static final String TAG = FileListPresenter.class.getSimpleName();

    /**
     * 定义一个Map用于记录打开的文件夹层级路径记录
     */
    private Map<Integer,String> fileOpenRecordMap = new HashMap<>();

    /**
     * 定义一个变量用于表示该页面打开的初始根路径
     */
    private String openRootPath = "";

    /**
     * 定义一个变量用于表示当前打开的文件路径
     */
    private String currentOpenPath = "";

    /**
     * 定义一个变量用于记录当前打开的目录层级，初始打开路径层级为0
     */
    private int currentOpenLevel = 0;

    /**
     * 定义一个方法用于读取文件路径
     * @param dirPath 待读取文件信息的文件路径
     * @param isRootPath 是否为初始打开根路径
     */
    @SuppressLint("CheckResult")
    public void loadFileList(String dirPath, boolean isRootPath, boolean isBack) {
        //显示进度条
        getView().showLoading();

        Observable.just(dirPath)
                .observeOn(Schedulers.computation())
                .map(path -> {
                    //记录下当前打开的文件路径
                    currentOpenPath = dirPath;

                    if (isRootPath){    //打开的为本次浏览的根路径
                        openRootPath = dirPath;
                        //添加到路径记录Map中
                        fileOpenRecordMap.put(0,path);
                    }else {             //不为根路径
                        if (!isBack){
                            //层级+1
                            currentOpenLevel++;
                            //添加到路径记录Map中
                            fileOpenRecordMap.put(currentOpenLevel,path);
                        }
                    }
                    Log.i(TAG, "loadFileList: 当前读取的层级为： " + currentOpenLevel + " 读取的文件路径为： " + currentOpenPath + " 本次是否为返回上一级： " + isBack);

//                        Logger.t(TAG).e(TAG + " 所有层级信息： " + fileOpenRecordMap);

                    List<FileInfo> fileInfoList = new ArrayList<>();
                    //判断文件路径是否有效
                    File fileDir = new File(path);
                    if (fileDir != null && fileDir.exists() && fileDir.isDirectory()) {       //文件夹存在
                        //遍历文件夹中的所有文件信息
                        File[] listFiles = fileDir.listFiles();
                        if (listFiles != null && listFiles.length > 0) {
                            for (File file : listFiles) {
                                FileInfo fileInfo = new FileInfo(file.getName(),
                                        FileUtils.ShowLongFileSzie(file.length()),
                                        FileUtils.getFilePermission(file),
                                        TimeUtils.timeStampToDate(file.lastModified(), "yyyy年MM月dd日 HH:mm:ss"),
                                        file.lastModified(), file.getPath(), file.isDirectory());
                                Log.e(TAG, "apply: 读取到的文件信息： " + fileInfo);

                                //添加到List中
                                fileInfoList.add(fileInfo);
                            }

                            //对List进行排序，以时间从新往旧排序
                            Collections.sort(fileInfoList, (file1, file2) -> {
                                if (file1.getFileLastModified() < file2.getFileLastModified()) {
                                    return 1;
                                } else if (file1.getFileLastModified() == file2.getFileLastModified()) {
                                    return 0;
                                } else {
                                    return -1;
                                }
                            });
                        }
                    }
                    return fileInfoList;
                }).observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<List<FileInfo>>() {
                    @Override
                    public void accept(List<FileInfo> fileInfos) throws Exception {
                        //刷新界面
                        getView().refreshFileList(fileInfos);
                        //更新标题栏
                        getView().refreshTittle();
                        //隐藏进度条
                        getView().hideLoading();
                    }
                });
    }

    /**
     * 定义一个方法用于返回当前浏览目录的上一层级
     * @return true表示 该层级已为根目录层级，无需再返回
     */
    public boolean backLastPathLevel(){
        Log.i(TAG, "backLastPathLevel: 当前浏览的层级为： " + currentOpenLevel + " 浏览的文件路径为： " + currentOpenPath);
        if (currentOpenLevel > 0){
            //当前层级-1
            int lastOpenLevel = currentOpenLevel - 1;
            if (lastOpenLevel > 0){
                //获取当前层级-1 后的 文件路径
                String lastOpenDir = fileOpenRecordMap.get(lastOpenLevel);
                Log.i(TAG, "backLastPathLevel: 即将返回的层级为： " + lastOpenLevel + " 返回的文件路径为： " + lastOpenDir);
                //当前层级-1
                currentOpenLevel--;
                //返回上一层级
                loadFileList(lastOpenDir,false,true);
                return false;
            }else if (lastOpenLevel == 0){      //返回后的层级为0
                //当前层级-1
                currentOpenLevel--;
                //返回至根目录层级
                loadFileList(openRootPath,true,true);
                return false;
            }else {
                getView().showMsg("返回异常，请重试或 " +
                        (SystemUtils.isTouchDevice() ? "按左上角按钮" : "(按*(←/✖))") + " 强制退出");
                return false;
            }
        }else if (currentOpenLevel == 0){
          //当前为根目录层级，无需返回
            Log.i(TAG, "backLastPathLevel: 当前为根目录层级，无需返回");
            return true;
        } else {
            getView().showMsg("层级异常，请重试或 " +
                    (SystemUtils.isTouchDevice() ? "按左上角按钮" : "(按*(←/✖))") + " 强制退出");
            return false;
        }
    }

    public String getCurrentOpenPath() {
        return currentOpenPath;
    }

    public boolean deleteAllFileByOpenPath(){
        boolean isSuccess = FileUtils.deleteDirFile(new File(currentOpenPath));
        getView().showMsg("删除 " + currentOpenPath + " 路径文件夹下的所有文件数据【" + (isSuccess ? "成功" : "失败") + "】");
        return isSuccess;
    }
}
